import requests
import json

from sympy import false

def send_agv_task(jobid, param_str):
    if jobid == "3001":
        # 保持原3001任务的处理逻辑不变
        """
        发送AGV任务请求
        
        Args:
            param_str: 可能是字符串或列表（如 ['washer']）
            
        Returns:
            成功/失败都返回统一JSON格式字符串
        """
        # 1. 处理输入参数（确保是字符串）
        if isinstance(param_str, list):
            if len(param_str) > 0:
                station_key = str(param_str[0])  # 取第一个元素转为字符串
            else:
                # 参数为空：返回JSON格式错误
                return json.dumps({
                    "status": 400,
                    "success": False,
                    "msg": "错误：传入的参数列表为空",
                    "response": {}
                }, ensure_ascii=False)
        else:
            station_key = str(param_str)
        
        print(f"转换后的station_key: {station_key}")  # 调试用

        # 2. 读取JSON配置文件
        json_path = "/mnt/d/ros_workspace/wsl_workspace/src/agv_ros2/agv_ros2/config/agvparams.json"
        try:
            with open(json_path, 'r', encoding='utf-8') as f:
                config = json.load(f)
        except FileNotFoundError:
            # 配置文件不存在：返回JSON格式错误
            return json.dumps({
                "status": 500,
                "success": False,
                "msg": f"错误：配置文件不存在（路径：{json_path}）",
                "response": {}
            }, ensure_ascii=False)
        except json.JSONDecodeError:
            # 配置文件格式错误：返回JSON格式错误
            return json.dumps({
                "status": 500,
                "success": False,
                "msg": "错误：配置文件格式无效（非标准JSON）",
                "response": {}
            }, ensure_ascii=False)
        
        # 3. 拼接URL
        url = f"http://{config['ip']}:{config['port']}/Api/Moma/AGVMoveTask"
        
        # 4. 获取station映射
        station = config['station_mapping'].get(station_key)  # 现在station_key是字符串
        if station is None:
            available = ", ".join(config['station_mapping'].keys())
            # 站点映射不存在：返回JSON格式错误
            return json.dumps({
                "status": 400,
                "success": False,
                "msg": f"未匹配到station映射（输入: {station_key}），可用选项: {available}",
                "response": {}
            }, ensure_ascii=False)
        
        # 5. 构造请求体
        data = {**config['fixed_params_3001'], "station": station}
        headers = {"Content-Type": "application/json"}

        response = requests.post(url, headers=headers, json=data, timeout=60)
        return json.dumps(response.json())
        # 6. 发送请求
        # try:
        #     response = requests.post(url, headers=headers, json=data, timeout=5)
        #     print(response)  # 调试用：打印响应对象
        #     if response.status_code == 200:
        #         # 请求成功：返回统一JSON格式（包含AGV响应）
        #         agv_resp = response.json()
        #         return json.dumps({
        #             "status": 200,
        #             "success": True,
        #             "msg": f"Moma [{config['fixed_params_3001']['name']}] move to [{station}] success",
        #             "response": agv_resp  # 携带AGV返回的原始数据
        #         }, ensure_ascii=False)
        #     else:
        #         # 请求失败（状态码非200）：返回JSON格式错误
        #         return json.dumps({
        #             "status": response.status_code,
        #             "success": False,
        #             "msg": f"请求失败，状态码：{response.status_code}",
        #             "response": {}
        #         }, ensure_ascii=False)
        # except requests.exceptions.RequestException as e:
        #     # 请求异常（超时/连接失败）：返回JSON格式错误
        #     return json.dumps({
        #         "status": 504,  # 504=网关超时，符合网络异常场景
        #         "success": False,
        #         "msg": f"请求异常：{e}",
        #         "response": {}
        #     }, ensure_ascii=False)

    elif jobid == "3002":
        """
        发送机器人动作任务请求（对应3002任务）
        
        Args:
            param_str: 字符串数组（如 ["1", "4"]），分别对应：
                      [MomaBufferNum, MomaLocationNum]
            
        Returns:
            成功返回服务器响应(JSON)，失败返回错误信息(str)
        """
        # 1. 处理输入参数（确保是包含2个元素的列表）
        if isinstance(param_str, list):
            if len(param_str) == 2:
                # 提取MomaBufferNum和MomaLocationNum
                moma_buffer_num = str(param_str[0])
                moma_location_num = str(param_str[1])
            else:
                return "错误：3002任务需要传入包含2个元素的列表（如[\"1\", \"4\"]）"
        else:
            # 若传入字符串，尝试按逗号分割（兼容类似"1,4"的输入）
            try:
                parts = param_str.split(',')
                if len(parts) == 2:
                    moma_buffer_num, moma_location_num = parts
                else:
                    return "错误：3002任务字符串格式应为\"MomaBufferNum,MomaLocationNum\"（如\"1,4\"）"
            except:
                return "错误：3002任务参数格式错误，需为列表或逗号分隔的字符串"
        
        print(f"解析参数：MomaBufferNum={moma_buffer_num}, MomaLocationNum={moma_location_num}")

        # 2. 读取JSON配置文件（复用同一个配置文件）
        json_path = "/mnt/d/ros_workspace/wsl_workspace/src/agv_ros2/agv_ros2/config/agvparams.json"
        try:
            with open(json_path, 'r', encoding='utf-8') as f:
                config = json.load(f)
        except FileNotFoundError:
            return f"错误：配置文件不存在（路径：{json_path}）"
        except json.JSONDecodeError:
            return "错误：配置文件格式无效（非标准JSON）"

        # 3. 拼接3002任务对应的URL
        url = f"http://{config['ip']}:{config['port']}/Api/Moma/RobotActionTask"

        # 4. 构造task_params列表（按需求映射参数）
        task_params = [
            {"Name": "StationNo", "Value": config['3002_params']['station_no']},  # 从配置文件读取
            {"Name": "StationBufferNum", "Value": config['3002_params']['station_buffer_num']},  # 从配置文件读取
            {"Name": "MomaBufferNum", "Value": moma_buffer_num},  # 来自param_str
            {"Name": "MomaLocationNum", "Value": moma_location_num},  # 来自param_str
            {"Name": "LoadType", "Value": config['3002_params']['load_type']}  # 固定值从配置文件读取
        ]

        # 5. 构造请求体（注意task_params需要转为字符串格式）
        data = {
            "name": config['fixed_params_3002']['name'],
            "arm": config['fixed_params_3002']['arm'],
            "task_no": config['fixed_params_3002']['task_no'],
            "task_params": json.dumps(task_params)  # 转换为JSON字符串
        }
        headers = {"Content-Type": "application/json"}
        print(data)
        # 6. 发送请求
        try:
            response = requests.post(url, headers=headers, json=data, timeout=5)
            print(response.status_code)
            if response.status_code == 200:
                return response.json()
            return f"请求失败，状态码：{response.status_code}，响应内容：{response.text}"
        except requests.exceptions.RequestException as e:
            return f"请求异常：{e}"
    elif jobid == "3003":
        """
        获取机器人状态信息（对应3003任务）
        
        Args:
            param_str: 字符串或列表，可选值为 "device"、"work"、"station"、"power"、"chargeState"
                      - "device": 获取设备状态（对应RobotDeviceState）
                      - "work": 获取工作状态（对应RobotWorkState）
                      - "station": 获取AGV站点信息（对应AGVStation）
                      - "power": 获取AGV电量信息（对应AGVPower）
                      - "chargeState": 获取AGV充电状态（对应AGVChargeState）
            
        Returns:
            成功返回服务器响应(JSON)，失败返回错误信息(str)
        """
        # 1. 处理输入参数（确保参数为字符串）
        # 处理列表类型的参数（如['power']）
        if isinstance(param_str, list):
            if len(param_str) > 0:
                state_key = str(param_str[0]).lower()  # 取第一个元素并转为小写
            else:
                return "错误：3003任务参数列表为空"
        else:
            # 处理字符串类型的参数
            state_key = str(param_str).lower()
        
        # 验证参数合法性（更新为3003_params中所有支持的键）
        valid_keys = ["device", "work", "station", "power", "program", "charge"]
        if state_key not in valid_keys:
            available = ", ".join(valid_keys)
            return f"错误：3003任务参数无效，可用选项: {available}"
        
        print(f"查询状态类型: {state_key}")

        # 2. 读取JSON配置文件
        json_path = "/mnt/d/ros_workspace/wsl_workspace/src/agv_ros2/agv_ros2/config/agvparams.json"
        try:
            with open(json_path, 'r', encoding='utf-8') as f:
                config = json.load(f)
        except FileNotFoundError:
            return f"错误：配置文件不存在（路径：{json_path}）"
        except json.JSONDecodeError:
            return "错误：配置文件格式无效（非标准JSON）"
        
        # 3. 确定要查询的状态类型和构建URL（使用处理后的字符串作为键）
        state_type = config['3003_params'][state_key]  # 支持新增的state_key映射
        moma_name = config['fixed_params_3002']['name']  # 复用moma名称
        url = f"http://{config['ip']}:{config['port']}/Api/Moma/{state_type}?moma={moma_name}"
        print(url)
        
        # 5. 发送GET请求（关键修复这里的return）
        try:
            response = requests.get(url, timeout=5)
            print(f"\n=== 正在请求底盘接口 ===")
            print(f"请求URL：{url}")
            print(f"接口响应状态码：{response.status_code}")

            if response.status_code == 200:
                print("获取底盘状态成功 get status success")
                chassis_data = response.json()  # AGV原始响应（已包含response字段）
                print("底盘返回的具体信息：")
                print(json.dumps(chassis_data, indent=2, ensure_ascii=False))
                
                # 关键：直接返回AGV原始响应（不再额外包装response），避免嵌套
                return json.dumps(chassis_data, ensure_ascii=False)  # 重点：返回AGV原始JSON字符串
            else:
                # 失败场景：构造和AGV成功响应格式一致的结构（避免robot_node解析逻辑混乱）
                error_resp = {
                    "status": response.status_code,
                    "success": False,
                    "msg": f"请求失败，状态码：{response.status_code}",
                    "response": {}  # 和成功响应保持相同的键，方便统一解析
                }
                return json.dumps(error_resp, ensure_ascii=False)

        except requests.exceptions.RequestException as e:
            # 修复：异常场景也返回JSON字符串
            return json.dumps({
                "status": 504,
                "success": False,
                "msg": f"请求异常：{e}",
                "response": {}
            }, ensure_ascii=False)
        
    elif jobid == "3004":
        """
        发送AGV充电任务请求（对应3004任务），控制充电开启/关闭
        
        Args:
            param_str: 字符串或列表，可选值为 "true"（开启充电）或 "false"（关闭充电）
            
        Returns:
            成功返回服务器响应(JSON)，失败返回错误信息(str)
        """
        # 1. 处理输入参数，确定充电动作（true=开启，false=关闭）
        action_str = ""
        if isinstance(param_str, list):
            if len(param_str) > 0:
                action_str = str(param_str[0]).lower()
            else:
                return "错误：3004任务参数列表为空"
        else:
            action_str = str(param_str).lower()
        
        # 验证参数合法性
        if action_str not in ["true", "false"]:
            return "错误：3004任务参数只能是 \"true\"（开启充电）或 \"false\"（关闭充电）"
        
        action_value = action_str == "true"  # 转换为布尔值
        print(f"充电操作：{'开启' if action_value else '关闭'}")

        # 2. 读取JSON配置文件
        json_path = "/mnt/d/ros_workspace/wsl_workspace/src/agv_ros2/agv_ros2/config/agvparams.json"
        try:
            with open(json_path, 'r', encoding='utf-8') as f:
                config = json.load(f)
        except FileNotFoundError:
            return f"错误：配置文件不存在（路径：{json_path}）"
        except json.JSONDecodeError:
            return "错误：配置文件格式无效（非标准JSON）"

        # 3. 拼接3004任务对应的URL
        url = f"http://{config['ip']}:{config['port']}/Api/Moma/AGVChargeTask"

        # 4. 构造请求体（name复用3002任务的配置，保持一致性）
        data = {
            "name": config['fixed_params_3002']['name'],
            "action": action_value
        }
        headers = {"Content-Type": "application/json"}
        print(f"请求体：{data}")

        # 5. 发送POST请求
        try:
            response = requests.post(url, headers=headers, json=data, timeout=5)
            print(f"响应状态码：{response.status_code}")
            if response.status_code == 200:
                return response.json()
            return f"请求失败，状态码：{response.status_code}，响应内容：{response.text}"
        except requests.exceptions.RequestException as e:
            return f"请求异常：{e}"
    else:
        return f"错误：未定义的jobid（{jobid}）"


def get_agv_station():
    """单独封装查询当前站点的函数（基于3003任务）"""
    json_path = "/mnt/d/ros_workspace/wsl_workspace/src/agv_ros2/agv_ros2/agvparams.json"
    try:
        with open(json_path, 'r', encoding='utf-8') as f:
            config = json.load(f)
    except Exception as e:
        print(f"配置文件读取失败: {e}")
        return None

    # 构造3003任务查询站点的请求
    state_type = config['3003_params']['station']  # 对应AGVStation
    moma_name = config['fixed_params_3002']['name']
    url = f"http://{config['ip']}:{config['port']}/Api/Moma/{state_type}?moma={moma_name}"

    try:
        response = requests.get(url, timeout=5)
        if response.status_code == 200:
            res_json = response.json()
            # 从data字段获取当前站点编号（字符串格式）
            return str(res_json.get("data")) if res_json.get("code") == 0 else None
        else:
            print(f"查询站点失败，状态码: {response.status_code}")
            return None
    except Exception as e:
        print(f"查询站点请求异常: {e}")
        return None